package com.xuetang9.service.sn.impl;

import com.github.pagehelper.PageHelper;
import com.xuetang9.dao.*;
import com.xuetang9.domain.*;
import com.xuetang9.dto.InputDto;
import com.xuetang9.dto.a.*;
import com.xuetang9.service.TaskService;
import com.xuetang9.utils.DateUtil;
import com.xuetang9.vo.ListVO;
import com.xuetang9.vo.TestUtil;
import com.xuetang9.vo.a.InspectionTaskByPoleVO;
import com.xuetang9.vo.a.InspectionTasksVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * @工能 任务表相关的业务处理实现类
 * @作者 杜目杰
 * @时间 2020/5/15
 * @地点 公司
 * @版本 1.0.0
 * @版权 老九学堂
 */
@Service
public class TaskServiceImpl implements TaskService {
    // task表的操作对象
    @Autowired
    TaskMapper taskMapper;
    //task_status表的操作对象
    @Autowired
    TaskStatusMapper taskStatusMapper;
    //user_task表的操作对象
    @Autowired
    UserTaskMapper userTaskMapper;
    //way表的操作对象
    @Autowired
    WayMapper wayMapper;
    //用户表操作对象
    @Autowired
    UserMapper userMapper;
    @Override
    public int update(Task task) {
        return taskMapper.updateTaskById(task);
    }
    /**
     * 处理任务表的查询业务
     *
     * @param inputDto 业务处理输入对象
     * @return 前端显示数据
     */
    @Override
    public ListVO selectTask(InputDto inputDto) {
        // 保存前端显示数据
        ListVO listVO = null;
        // 得到要处理的业务名称
        String in = inputDto.function;
        //选中对应的功能处理业务
        switch (in) {
            case "查询":
                listVO = listTaskA(inputDto);
                break;
            case "查询任务进度":
                listVO = selectTaskDetails(inputDto);
                break;
        }
        return listVO;
    }

    /**
     *  巡检任务进度查询
     * @param inputDto 类型为Task的输入对象
     * @return 查询显示对象
     */
    private ListVO selectTaskDetails(InputDto<ListRequestDTO<SelectTaskDetailsDTO>> inputDto) {
        ListVO listVO = new ListVO();
        PageHelper.startPage(inputDto.date.page,inputDto.date.pageSize);
        SelectTaskDetailsDTO selectTaskDetailsDTO = inputDto.date.request;
        if (selectTaskDetailsDTO == null){
            selectTaskDetailsDTO = new SelectTaskDetailsDTO();
        }
        InspectionTaskByPoleVO  in = selectByIdAndPoleId(selectTaskDetailsDTO.gettId(),selectTaskDetailsDTO.getPoleId());
        if (in == null){
            return null;
        }
        if (in.getTaskTaskCreate() != null ){
            in.setTaskCreate(DateUtil.changeStyle(in.getTaskTaskCreate()));
        }
        if (in.getPdCreateTime() != null){
            in.setFindTime(DateUtil.changeStyle(in.getPdCreateTime()));
        }
        listVO.setResult(in);
        return listVO;
    }

    /**
     * 分配任务
     * @param inputDto 业务处理输入对象
     * @return 分配结果
     */
    @Override
    public int updateTask(InputDto inputDto) {
        // 保存新增结果
        int result = -1;
        // 得到要处理的业务名称
        String in = inputDto.function;
        //选中对应的功能处理业务
        switch (in) {
            case "任务分配":
                result = taskAllocation(inputDto.date);
                break;
        }
        return result;
    }

    /**
     *  完成任务分配
     * @param date  请求数据
     * @return 处理结果
     */
    private int taskAllocation(Object date) {
        if (date == null){
            return 0;
        }
        int times = 0;
        TaskAllocationDTO dto = (TaskAllocationDTO)date;
        UserTask userTask = new UserTask();
        userTask.setId(dto.getTaskId());
        for (Integer i: dto.getUsers()
             ) {
            userTask.setReceiverId(i);
            if (userTaskMapper.insertUserTask(userTask) > 0){
                times ++;
            }
        }
        // 组装任务-状态表的数据
        String taskId = taskMapper.selectTaskIdById(dto.getTaskId());
        TaskStatus taskStatus = setTaskStatus(taskId, 2);
        // 给任务绑定状态
        int insertTaskStatusResult = insertTaskStatus(taskStatus);
        return times;
    }

    /**
     * 修改任务状态的记录
     * @param taskStatus 任务-状态表对象的新数据
     * @return 更新结果
     */
    private int updateTaskStatus(TaskStatus taskStatus) {
        return taskStatusMapper.updateByPrimaryTaskId(taskStatus);
    }

    /**
     * 取消任务
     * @param id 任务id
     * @return 取消结果
     */
    @Override
    public int deleteTask(int id) {
        String taskId = taskMapper.selectTaskIdById(id);
        if (taskId == null){
            return -1;
        }
        TaskStatus taskStatus = setTaskStatus(taskId, 4);
        // 给任务绑定状态
        int insertTaskStatusResult = insertTaskStatus(taskStatus);
        Task task = new Task();
        task.setId(id);
        task.setTaskId(taskMapper.selectTaskIdById(id));
        task.setTaskStatus("4");
        return taskMapper.updateTaskById(task);
    }

    /**
     * 插入添加任务
     * @param inputDto 业务处理输入对象
     * @return 插入结果
     */
    @Override
    public int insertTask(InputDto inputDto) {
        // 保存新增结果
        int result = -1;
        // 得到要处理的业务名称
        String in = inputDto.function;
        //选中对应的功能处理业务
        switch (in) {
            case "制定巡检任务":
                result = createTask(inputDto);
                break;
            case "巡检回执录入":
                result = createTask(inputDto);
                break;
        }
        return result;
    }


    /**
     * 根据输入内容查询
     * @param inputDto 类型为Task的输入对象
     * @return 查询显示对象
     */
    public ListVO listTaskA(InputDto<ListRequestDTO<InspectionTasksDTO>> inputDto) {
        // 组装任务表的查询对象
        Task task = getTaskFromInspectionTasksDTO(inputDto.date.request);
        // 得到主表的查询结果
        List<Task> tasks = selectByTask(task);
        // 得的最终显示结果
        List<InspectionTasksVO> inspectionTasksVOS = new ArrayList<>();
        InspectionTasksVO inspectionTasksVO;
        int times = 0;
        int page = inputDto.date.page;
        int pageSize = inputDto.date.pageSize;
        if (tasks != null && tasks.size() > 0) {
            for (Task t : tasks
            ) {
                inspectionTasksVO = getInspectionTasksVOByTaskAndInspectionTasksDTO(t, inputDto.date.request);
                if (inspectionTasksVO != null){
                    times ++;
                    // 分页
                    if (times > (page-1)*pageSize && times <= page * pageSize){
                        inspectionTasksVOS.add(inspectionTasksVO);
                    }
                }
            }
        }
        // 配置显示集合
        ListVO<List<InspectionTasksVO>> listVO = new ListVO();
        listVO.setResult(inspectionTasksVOS);
        listVO.setTotal(times);
        return listVO;
    }

    /**
     *  查询任务进度详情
     * @param task     待检测对象
     * @param inputDto 查询条件
     * @return 显示对象
     */
    private InspectionTasksVO getInspectionTasksVOByTaskAndInspectionTasksDTO(Task task, InspectionTasksDTO inputDto) {

        // 检测时间

        // 检测下发人
        //通过任务id得到下发人id
        UserTask userTask = new UserTask();
        userTask.setId(task.getId());
        List<UserTask> userTaskList = userTaskMapper.select(userTask);
        // 通过下发人id得到下发人姓名
        if (userTaskList.size() == 0) {
            return null;
        }
        userTask = userTaskList.get(0);
        userTask.setId(task.getId());
        User user = userMapper.listById(userTask.getSenderId());
        String issueUser;
        issueUser = user.getName();
        // 配置显示对象
        InspectionTasksVO vo = new InspectionTasksVO();
        vo.setId(task.getId());// 任务编号
        vo.setTaskName(task.getTaskInfo());
        vo.setTaskStatus(task.getTaskStatus());
        vo.setTaskId(task.getTaskId()); // 任务编码
        vo.setIssueUser(issueUser);// 下发人
        vo.setIssueTime(task.getTaskCreate()); // 下发时间
        // 通过线路编号得到起始杆号和终止杆号
        Way way = new Way();
        way.setWayId(task.getWayId());
        List<Way> ways = wayMapper.select(way);
        if (ways.size() > 0) {
            way = ways.get(0);
        }
        if (way != null) {
            vo.setFirstPoleId(way.getPoleFirst()); // 起始杆号
            vo.setLastPoleId(way.getPoleLast()); // 终止杆号
            vo.setWayName(way.getWayName()); // 线路名
        }
        // 通过任务编号得到完成时间和是否取消状态
        // 通过任务编号得到任务-状态
        Map<String, Date> map = new HashMap();
        TaskStatus task1 = new TaskStatus();
        task1.setTaskId(task.getTaskId());
        List<TaskStatus> status = taskStatusMapper.select(task1);
        if (status.size() > 0) {
            for (TaskStatus t : status
            ) {
                map.put(t.getWorkinfoId(), t.getTaskChangeTime());
            }
        }
        vo.setFinishTime(map.get("5"));// 完成时间
        vo.setCancel(map.get("4") != null);// 是否取消
        return vo;
    }

    /** 提取task表的查询条件
     * @param date 查询条件
     * @return task查询对象
     */
    private Task getTaskFromInspectionTasksDTO(InspectionTasksDTO date) {
        Task task = new Task();
        task.setTaskId(date.getTaskId());
        task.setWayId(date.getWayId());
        task.setTaskStatus(date.getTaskStatus());
        return task;
    }

    ;

    /**
     * 制定任务
     *
     * @param inputDto 类型为Task的输入对象
     * @return 保存结果
     */
    public int createTask(InputDto<AddInspectionTaskDTO> inputDto) {
        AddInspectionTaskDTO dto = inputDto.date;
        if (dto == null){
            return 0;
        }
        // 组装任务表的数据
        Task task = setTask(inputDto.date.getTask_id(), inputDto.date.getTask_name(), inputDto.date.getInspection_line(), "巡检任务", "待分配");
        // 添加结果
        int insertTaskResult = insertByTask(task);
        // 得到新增任务的主键id
        int id = getLastTaskId(task);
        // 给任务绑定用户和状态
        if (insertTaskResult != -1) {
            // 组装任务-用户表的数据
            if (dto.getIssued_person_Id() == null){
                return 0;
            }
            UserTask userTask = setUserTask(dto.getIssued_person_Id(), id);
            // 给任务表绑定用户
            int insertUserTaskResult = insertUserTask(userTask);
            // 组装任务-状态表的数据
            TaskStatus taskStatus = setTaskStatus(inputDto.date.getTask_id(), 0);
            // 给任务绑定状态
            int insertTaskStatusResult = insertTaskStatus(taskStatus);
        }
        return insertTaskResult;
    }

    /**
     * 将属于task表的查询条件组装为task 的查询对象
     *
     * @param task_id         任务编码
     * @param task_name       任务名
     * @param inspection_line 线路名
     * @param taskTyp         任务类型
     * @return 任务表对应的实例对象
     */
    private Task setTask(String task_id, String task_name, String inspection_line, String taskTyp, String taskStatus) {

        Task task = new Task();
        task.setTaskId(task_id);
        task.setTaskInfo(task_name);
        task.setWayId(inspection_line);
        task.setTaskType(taskTyp);
        task.setTaskStatus(taskStatus);
        return task;
    }

    /**
     * 得到新建任务的主键id
     *
     * @param task 封装为Task对象的查询条件
     * @return 查询集合中最后一个任务的id
     */
    public int getLastTaskId(Task task) {
        List<Task> tasks = selectByTask(task);
        int id = -1;
        if (tasks.size() >= 1) {
            id = tasks.get(tasks.size() - 1).getId();
        }
        return id;
    }

    /**
     * Task的实例化对象查询task表
     *
     * @param task 封装为Task对象的查询条件
     * @return Task集合的查询结果
     */
    public List<Task> selectByTask(Task task) {
        return taskMapper.listTask(task);
    }

    /**
     * 组装UserTask的数据
     *
     * @param senderId   发布人id
     * @param id         状态id
     * @return UserTask的实例化对象
     */
    public UserTask setUserTask(int senderId,  int id) {
        UserTask userTask = new UserTask();
        userTask.setId(id);
        userTask.setSenderId(senderId);
        return userTask;
    }



    /**
     * 组装TaskStatus表的数据
     *
     * @param tableId     way/taskd的编号
     * @param workInForId wokinfor的id
     * @return TaskStatus的实例化对象
     */
    public TaskStatus setTaskStatus(String tableId, int workInForId) {
        // 创建一个任务状态表的对象
        TaskStatus taskStatus = new TaskStatus();
        // 设置TaskId为新建任务的任务编号
        taskStatus.setTaskId(tableId);
        // 设置状态为待分配
        taskStatus.setWorkinfoId(workInForId + "");
        return taskStatus;
    }
    public InspectionTaskByPoleVO selectByIdAndPoleId(int tId , String poleId){
        return taskMapper.selectByIdAndPoleId(tId,poleId);
    }
    /**
     * 保存userTask表的数据
     *
     * @param userTask UserTask类的对象
     * @return 保存的结果
     */
    public int insertUserTask(UserTask userTask) {
        return userTaskMapper.insertUserTask(userTask);
    }
    /**
     * 新增线路/任务-状态
     *
     * @param taskStatus 主表与状态表的中间表对象
     * @return 添加结果
     */
    public int insertTaskStatus(TaskStatus taskStatus) {
        return taskStatusMapper.insertTaskStatus(taskStatus);
    }

    /**
     * 添加任务
     *
     * @param task 任务
     * @return 添加任务的结果
     */
    public int insertByTask(Task task) {
        return taskMapper.insertTask(task);
    }
}
